package com.zy.je.common.core.utils.lang;


import com.zy.je.common.core.utils.CheckUtil;
import org.dromara.hutool.core.math.NumberUtil;
import org.dromara.hutool.core.util.BooleanUtil;
import org.dromara.hutool.core.util.ObjUtil;
import org.springframework.beans.BeanUtils;

import java.math.BigDecimal;
import java.util.function.Consumer;
import java.util.function.Supplier;


public class ObjectUtil extends ObjUtil {

    /**
     * 转换为BigDecimal类型
     */
    public static BigDecimal toBigDecimal(Object val) {
        if (val == null) {
            return new BigDecimal(0);
        }
        try {
            return new BigDecimal(StringUtil.trim(val.toString()));
        } catch (Exception e) {
            return new BigDecimal(0);
        }
    }

    /**
     * 转换为BigDecimal类型
     */
    public static BigDecimal toBigDecimal(Object val, BigDecimal defaultValue) {
        if (val == null) {
            return defaultValue;
        }
        try {
            return new BigDecimal(StringUtil.trim(val.toString()));
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 转换为Double类型
     */
    public static Double toDouble(final Object val) {
        if (val == null) {
            return 0D;
        }
        try {
            return NumberUtil.toBigDecimal(StringUtil.trim(val.toString())).doubleValue();
        } catch (Exception e) {
            return 0D;
        }
    }

    /**
     * 转换为Double类型
     */
    public static Double toDouble(final Object val, Double defaultValue) {
        if (val == null) {
            return defaultValue;
        }
        try {
            return NumberUtil.toBigDecimal(StringUtil.trim(val.toString())).doubleValue();
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 转换为Float类型
     */
    public static Float toFloat(final Object val) {
        return toDouble(val).floatValue();
    }

    /**
     * 转换为Double类型
     */
    public static Float toFloat(final Object val, Float defaultValue) {
        Double aDouble = toDouble(val, null != defaultValue ? defaultValue.doubleValue() : null);
        if (null != aDouble) {
            return aDouble.floatValue();
        }
        return defaultValue;
    }

    /**
     * 转换为Long类型
     */
    public static Long toLong(final Object val) {
        return toDouble(val).longValue();
    }

    /**
     * 转换为Double类型
     */
    public static Long toLong(final Object val, Long defaultValue) {
        Double aDouble = toDouble(val, null != defaultValue ? defaultValue.doubleValue() : null);
        if (null != aDouble) {
            return aDouble.longValue();
        }
        return defaultValue;
    }

    /**
     * 转换为Integer类型
     */
    public static Integer toInteger(final Object val) {
        return toLong(val).intValue();
    }

    /**
     * 转换为Double类型
     */
    public static Integer toInteger(final Object val, Integer defaultValue) {
        Double aDouble = toDouble(val, null != defaultValue ? defaultValue.doubleValue() : null);
        if (null != aDouble) {
            return aDouble.intValue();
        }
        return defaultValue;
    }

    /**
     * 转换为Boolean类型 "true", "yes", "y", "t", "ok", "1", "on", "是", "对", "真", "對", "√" (case insensitive) will
     * return true. Otherwise, false is returned.
     */
    public static Boolean toBoolean(final Object val) {
        return toBoolean(val.toString(), false);
    }

    public static Boolean toBoolean(final Object val, final Boolean defaultVal) {
        if (val == null) {
            return defaultVal;
        }
        return BooleanUtil.toBoolean(val.toString());
    }

    /**
     * 转换为字符串
     *
     * @param obj
     * @return
     */
    public static String toString(final Object obj) {
        return toString(obj, StringUtil.EMPTY);
    }

    /**
     * 如果对象为空，则使用defaultVal值
     *
     * @param obj
     * @param defaultVal
     * @return
     */
    public static String toString(final Object obj, final String defaultVal) {
        return obj == null ? defaultVal : obj.toString();
    }

    /**
     * 空转空字符串（"" to "" ; null to "" ; "null" to "" ; "NULL" to "" ; "Null" to ""）
     *
     * @param val 需转换的值
     * @return 返回转换后的值
     */
    public static String toStringIgnoreNull(final Object val) {
        return ObjectUtil.toStringIgnoreNull(val, StringUtil.EMPTY);
    }

    /**
     * 空对象转空字符串 （"" to defaultVal ; null to defaultVal ; "null" to defaultVal ;
     * "NULL" to defaultVal ; "Null" to defaultVal）
     *
     * @param val        需转换的值
     * @param defaultVal 默认值
     * @return 返回转换后的值
     */
    public static String toStringIgnoreNull(final Object val, String defaultVal) {
        String str = ObjectUtil.toString(val);
        return !"".equals(str) && !"null".equals(str.trim().toLowerCase()) ? str : defaultVal;
    }

    /**
     * 拷贝一个对象（但是子对象无法拷贝）
     *
     * @param source
     * @param ignoreProperties
     */
    public static Object copyBean(Object source, String... ignoreProperties) {
        if (source == null) {
            return null;
        }
        Object target = BeanUtils.instantiate(source.getClass());
        BeanUtils.copyProperties(source, target, ignoreProperties);
        return target;
    }


    /**
     * 忽略Exception的获取
     *
     * @param supplier
     * @param <T>
     * @return 如果有空指针，返回null
     */
    public static <T> T ifNoneToNull(Supplier<T> supplier) {
        try {
            return supplier.get();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 忽略Exception的获取
     *
     * @param supplier
     * @param or
     * @param <T>
     * @return 如果有空指针，返回or
     */
    public static <T> T ifNoneToDefault(Supplier<T> supplier, T or) {
        try {
            T t = supplier.get();
            if (t != null) {
                return t;
            }
            return or;
        } catch (Exception e) {
            return or;
        }
    }

    public static <T> void ifNotNoneDoFn(T value, Consumer<T> fn) {
//        if (null == value) {
//            return;
//        }
//        if (value instanceof String) {
//            if (StringUtils.isBlank((String) value)) {
//                return;
//            }
//        } else {
////            String valueString =  ObjectUtils.toString(value);
////            if (CheckUtils.isBlankString(valueString)) {
////                return;
////            }
//        }
        if (!CheckUtil.isBlank(value)) {
            fn.accept(value);
        }
    }

}
